Ham Radio 2000 #1/Ham Radio 2000.iso/ham2000/tcp_ip/wnos/wn941101/nr4subr.c

C/C++ Source or Header | 1994-08-10 | 4.7 KB | 203 lines

/*
 * nr4subr.c:  subroutines for net/rom transport layer.
 * Copyright 1989 by Daniel M. Frank, W9NK.  Permission granted for
 * non-commercial distribution only.
 */

#include <stdio.h>
#include "global.h"
#include "config.h"
#ifdef NETROM
#include "mbuf.h"
#include "timer.h"
#include "ax25.h"
#include "netrom.h"
#include "nr4.h"
#include <ctype.h>

/* Get a free circuit table entry, and allocate a circuit descriptor.
 * Initialize control block circuit number and ID fields.
 * Return a pointer to the circuit control block if successful,
 * NULLNR4CB if not.
 */
struct nr4cb *
new_n4circ()
{
    int i ;
    struct nr4cb *cb ;

    for (i = 0 ; i <  NR4MAXCIRC ; i++)        /* find a free circuit */
        if (Nr4circuits[i].ccb == NULLNR4CB)
            break ;

    if (i == NR4MAXCIRC)
        return NULLNR4CB;

    Nr4circuits[i].ccb = (struct nr4cb *)mxallocw(sizeof(struct nr4cb));

    cb = Nr4circuits[i].ccb;
    cb->mynum = i ;
    cb->myid = Nr4circuits[i].cid ;

    /* set l4 inactivity timer to 30 mins */
    cb->inactivity.func = (void (*) __ARGS((void *))) reset_nr4;
    cb->inactivity.arg = cb;
    set_timer(&cb->inactivity,900000L);

    return cb ;
}

/* Set the window size for a circuit and allocate the buffers for
 * the transmit and receive windows.  Set the control block window
 * parameter.  Return 0 if successful, -1 if not.
 */
int
init_nr4window(struct nr4cb *cb,unsigned window)
{
    if (window == 0 || window > NR4MAXWIN) /* reject silly window sizes */
        window = 1;

    cb->txbufs =
         (struct nr4txbuf *)cxallocw(window,sizeof(struct nr4txbuf));

    cb->rxbufs =
         (struct nr4rxbuf *)cxallocw(window,sizeof(struct nr4rxbuf));

    cb->window = window ;

    return 0 ;
}

/* Free a circuit.  Deallocate the control block and buffers, and
 * increment the circuit ID.  No return value.
 */
void
free_n4circ(struct nr4cb *cb)
{
    unsigned circ = cb->mynum;

    if (cb == NULLNR4CB)
        return ;

    if (cb->txbufs != (struct nr4txbuf *)0)
        xfree(cb->txbufs) ;

    if (cb->rxbufs != (struct nr4rxbuf *)0)
        xfree(cb->rxbufs) ;

    stop_timer(&cb->inactivity);    /* stop it */

    /* Better be safe than sorry: */
    free_q(&cb->txq) ;
    free_q(&cb->rxq) ;

    xfree(cb) ;

    if (circ > NR4MAXCIRC)        /* Shouldn't happen. */
        return ;

    Nr4circuits[circ].ccb = NULLNR4CB ;
    Nr4circuits[circ].cid++ ;
    return;
}

/* See if any open circuit matches the given parameters.  This is used
 * to prevent opening multiple circuits on a duplicate connect request.
 * Returns the control block address if a match is found, or NULLNR4CB
 * otherwise.
 */
struct nr4cb *
match_n4circ(index, id, user, node)
int index ;                    /* index of remote circuit */
int id ;                    /* id of remote circuit */
char *user ;    /* address of remote user */
char *node ;    /* address of originating node */
{
    int i ;
    struct nr4cb *cb ;

    for (i = 0 ; i < NR4MAXCIRC ; i++) {
        if ((cb = Nr4circuits[i].ccb) == NULLNR4CB)
            continue ;        /* not an open circuit */
        if (cb->yournum == index && cb->yourid == id
          && addreq(cb->remote.user,user)
          && addreq(cb->remote.node,node))
            return cb ;
    }
    /* if we get to here, we didn't find a match */
    return NULLNR4CB ;
}

/* Validate the index and id of a local circuit, returning the control
 * block if it is valid, or NULLNR4CB if it is not.
 */
struct nr4cb *
get_n4circ(index, id)
int index ;                /* local circuit index */
int id ;                /* local circuit id */
{
    struct nr4cb *cb ;

    if (index >= NR4MAXCIRC || (cb = Nr4circuits[index].ccb) == NULLNR4CB)
        return NULLNR4CB ;

    return (cb->myid == id) ? cb : NULLNR4CB ;
}

/* Return 1 if b is "between" (modulo the size of an unsigned char)
 * a and c, 0 otherwise.
 */
int
nr4between(unsigned a,unsigned b,unsigned c)
{
    return ((a <= b && b < c) || (c < a && a <= b) || (b < c && c < a)) ? 1 : 0;
}

/* Set up default timer values, etc., in newly connected control block.
 */
void
nr4defaults(struct nr4cb *cb)
{
    int i ;
    struct timer *t ;

    if (cb == NULLNR4CB)
        return ;

    /* Set up the ACK and CHOKE timers */

    set_timer(&cb->tack,Nr4acktime * 1000) ;
    cb->tack.func = nr4ackit ;
    cb->tack.arg = cb ;

    set_timer(&cb->tchoke,Nr4choketime * 1000) ;
    cb->tchoke.func = nr4unchoke ;
    cb->tchoke.arg = cb ;

    cb->rxpastwin = cb->window ;

    /* Don't actually set the timers, since this is done in nr4sbuf */
    for (i = 0 ; i < cb->window ; i++) {
        t = &cb->txbufs[i].tretry ;
        t->func = nr4txtimeout ;
        t->arg = cb ;
    }
    return;
}

/* See if this control block address is valid */

int
nr4valcb(struct nr4cb *cb)
{
    int i;

    if (cb != NULLNR4CB) {
        for (i = 0 ; i < NR4MAXCIRC ; i++)
            if (Nr4circuits[i].ccb == cb)
                return 1 ;
    }
    return 0 ;
}

#endif /* NETROM */